home *** CD-ROM | disk | FTP | other *** search
/ Amiga Collections: Purity / Purity #42 (1995-01)(PackMAN)(DE)[WB].zip / Purity #42 (1995-01)(PackMAN)(DE)[WB].adf / Includes3v1 / Includes3v1.lha / Rexx / Storage.i < prev   
Text File  |  1994-12-04  |  11KB  |  308 lines
  1. { === rexx/storage.h ==================================================
  2.  *
  3.  * Copyright (c) 1986, 1987 by William S. Hawes (All Rights Reserved)
  4.  *
  5.  * =====================================================================
  6.  * Header file to define ARexx data structures.
  7. }
  8.  
  9. {$I "Include:Exec/Nodes.i"}
  10. {$I "Include:Exec/Lists.i"}
  11. {$I "Include:Exec/Ports.i"}
  12. {$I "Include:Exec/Libraries.i"}
  13.  
  14. { The NexxStr structure is used to maintain the internal strings in REXX.
  15.  * It includes the buffer area for the string and associated attributes.
  16.  * This is actually a variable-length structure; it is allocated for a
  17.  * specific length string, and the length is never modified thereafter
  18.  * (since it's used for recycling).
  19.  }
  20.  
  21. Type
  22.  
  23.     NexxStr = record
  24.     ns_Ivalue    : Integer;    { integer value                 }
  25.     ns_Length    : Short;    { length in bytes (excl null)   }
  26.     ns_Flags    : Byte;        { attribute flags               }
  27.     ns_Hash        : Byte;        { hash code                     }
  28.     ns_Buff        : Array [0..7] of Byte;
  29.                     { buffer area for strings       }
  30.     end;                { size: 16 bytes (minimum)      }
  31.     NexxStrPtr = ^NexxStr;
  32.  
  33. Const
  34.  
  35.     NXADDLEN    = 9;            { offset plus null byte         }
  36.  
  37. { String attribute flag bit definitions                                }
  38.  
  39.     NSB_KEEP    = 0;            { permanent string?             }
  40.     NSB_STRING    = 1;            { string form valid?            }
  41.     NSB_NOTNUM    = 2;            { non-numeric?                  }
  42.     NSB_NUMBER    = 3;            { a valid number?               }
  43.     NSB_BINARY    = 4;            { integer value saved?          }
  44.     NSB_FLOAT    = 5;            { floating point format?        }
  45.     NSB_EXT    = 6;            { an external string?           }
  46.     NSB_SOURCE    = 7;            { part of the program source?   }
  47.  
  48. { The flag form of the string attributes                               }
  49.  
  50.     NSF_KEEP    = 1;
  51.     NSF_STRING    = 2;
  52.     NSF_NOTNUM    = 4;
  53.     NSF_NUMBER    = 8;
  54.     NSF_BINARY    = 16;
  55.     NSF_FLOAT    = 32;
  56.     NSF_EXT    = 64;
  57.     NSF_SOURCE    = 128;
  58.  
  59. { Combinations of flags                                                }
  60.  
  61.     NSF_INTNUM    = NSF_NUMBER + NSF_BINARY + NSF_STRING;
  62.     NSF_DPNUM    = NSF_NUMBER + NSF_FLOAT;
  63.     NSF_ALPHA    = NSF_NOTNUM + NSF_STRING;
  64.     NSF_OWNED    = NSF_SOURCE + NSF_EXT    + NSF_KEEP;
  65.     KEEPSTR    = NSF_STRING + NSF_SOURCE + NSF_NOTNUM;
  66.     KEEPNUM    = NSF_STRING + NSF_SOURCE + NSF_NUMBER + NSF_BINARY;
  67.  
  68. { The RexxArg structure is identical to the NexxStr structure, but
  69.  * is allocated from system memory rather than from internal storage.
  70.  * This structure is used for passing arguments to external programs.
  71.  * It is usually passed as an "argstring", a pointer to the string buffer.
  72. }
  73.  
  74. Type
  75.  
  76.     RexxArg = record
  77.     ra_Size        : Integer;    { total allocated length        }
  78.     ra_Length    : Short;    { length of string              }
  79.     ra_Flags    : Byte;        { attribute flags               }
  80.     ra_Hash        : Byte;        { hash code                     }
  81.     ra_Buff        : Array [0..7] of Byte;
  82.                     { buffer area                   }
  83.     end;                { size: 16 bytes (minimum)      }
  84.     RexxArgPtr = ^RexxArg;
  85.  
  86. { The RexxMsg structure is used for all communications with REXX
  87.  * programs.  It is an EXEC message with a parameter block appended.
  88. }
  89.  
  90.     RexxMsg = record
  91.     rm_Node        : Message;    { EXEC message structure        }
  92.     rm_TaskBlock    : Address;    { global structure (private)    }
  93.     rm_LibBase    : Address;    { library base (private)        }
  94.     rm_Action    : Integer;    { command (action) code         }
  95.     rm_Result1    : Integer;    { primary result (return code)  }
  96.     rm_Result2    : Integer;    { secondary result              }
  97.     rm_Args        : Array [0..15] of String;
  98.                     { argument block (ARG0-ARG15)   }
  99.  
  100.     rm_PassPort    : MsgPortPtr;    { forwarding port               }
  101.     rm_CommAddr    : String;    { host address (port name)      }
  102.     rm_FileExt    : String;    { file extension                }
  103.     rm_Stdin    : Address;    { input stream (filehandle)     }
  104.     rm_Stdout    : Address;    { output stream (filehandle)    }
  105.     rm_avail    : Integer;    { future expansion              }
  106.     end;                { size: 128 bytes               }
  107.     RexxMsgPtr = ^RexxMsg;
  108.  
  109. Const
  110.  
  111.     MAXRMARG        = 15;        { maximum arguments             }
  112.  
  113. { Command (action) codes for message packets                           }
  114.  
  115.     RXCOMM        = $01000000;    { a command-level invocation    }
  116.     RXFUNC        = $02000000;    { a function call               }
  117.     RXCLOSE        = $03000000;    { close the REXX server         }
  118.     RXQUERY        = $04000000;    { query for information         }
  119.     RXADDFH        = $07000000;    { add a function host           }
  120.     RXADDLIB        = $08000000;    { add a function library        }
  121.     RXREMLIB        = $09000000;    { remove a function library     }
  122.     RXADDCON        = $0A000000;    { add/update a ClipList string  }
  123.     RXREMCON        = $0B000000;    { remove a ClipList string      }
  124.     RXTCOPN        = $0C000000;    { open the trace console        }
  125.     RXTCCLS        = $0D000000;    { close the trace console       }
  126.  
  127. { Command modifier flag bits                                           }
  128.  
  129.     RXFB_NOIO        = 16;        { suppress I/O inheritance?     }
  130.     RXFB_RESULT        = 17;        { result string expected?       }
  131.     RXFB_STRING        = 18;        { program is a "string file"?   }
  132.     RXFB_TOKEN        = 19;        { tokenize the command line?    }
  133.     RXFB_NONRET        = 20;        { a "no-return" message?        }
  134.  
  135. { The flag form of the command modifiers                               }
  136.  
  137.     RXFF_NOIO        = $00010000;
  138.     RXFF_RESULT        = $00020000;
  139.     RXFF_STRING        = $00040000;
  140.     RXFF_TOKEN        = $00080000;
  141.     RXFF_NONRET        = $00100000;
  142.  
  143.     RXCODEMASK        = $FF000000;
  144.     RXARGMASK        = $0000000F;
  145.  
  146. { The RexxRsrc structure is used to manage global resources.  Each node 
  147.  * has a name string created as a RexxArg structure, and the total size
  148.  * of the node is saved in the "rr_Size" field.  The REXX systems library
  149.  * provides functions to allocate and release resource nodes.  If special
  150.  * deletion operations are required, an offset and base can be provided in
  151.  * "rr_Func" and "rr_Base", respectively.  This "autodelete" function will
  152.  * be called with the base in register A6 and the node in A0.
  153.  }
  154.  
  155. Type
  156.  
  157.     RexxRsrc = record
  158.     rr_Node        : Node;
  159.     rr_Func        : Short;    { "auto-delete" offset          }
  160.     rr_Base        : Address;    { "auto-delete" base            }
  161.     rr_Size        : Integer;    { total size of node            }
  162.     rr_Arg1        : Integer;    { available ...                 }
  163.     rr_Arg2        : Integer;    { available ...                 }
  164.     end;                { size: 32 bytes                }
  165.     RexxRsrcPtr = ^RexxRsrc;
  166.  
  167. Const
  168.  
  169. { Resource node types                                                  }
  170.  
  171.     RRT_ANY        = 0;        { any node type ...             }
  172.     RRT_LIB        = 1;        { a function library            }
  173.     RRT_PORT        = 2;        { a public port                 }
  174.     RRT_FILE        = 3;        { a file IoBuff                 }
  175.     RRT_HOST        = 4;        { a function host               }
  176.     RRT_CLIP        = 5;        { a Clip List node              }
  177.  
  178. { The RexxTask structure holds the fields used by REXX to communicate with
  179.  * external processes, including the client task.  It includes the global
  180.  * data structure (and the base environment).  The structure is passed to
  181.  * the newly-created task in its "wake-up" message.
  182.  }
  183.  
  184.     GLOBALSZ        = 200;        { total size of GlobalData      }
  185.  
  186. Type
  187.  
  188.     RexxTask = record
  189.     rt_Global    : Array [0..GLOBALSZ-1] of Byte;
  190.                     { global data structure         }
  191.     rt_MsgPort    : MsgPort;    { global message port           }
  192.     rt_Flags    : Byte;        { task flag bits                }
  193.     rt_SigBit    : Byte;        { signal bit                    }
  194.  
  195.     rt_ClientID    : Address;    { the client's task ID          }
  196.     rt_MsgPkt    : Address;    { the packet being processed    }
  197.     rt_TaskID    : Address;    { our task ID                   }
  198.     rt_RexxPort    : Address;    { the REXX public port          }
  199.  
  200.     rt_ErrTrap    : Address;    { Error trap address            }
  201.     rt_StackPtr    : Address;    { stack pointer for traps       }
  202.  
  203.     rt_Header1    : List;        { Environment list              }
  204.     rt_Header2    : List;        { Memory freelist               }
  205.     rt_Header3    : List;        { Memory allocation list        }
  206.     rt_Header4    : List;        { Files list                    }
  207.     rt_Header5    : List;        { Message Ports List            }
  208.     end;
  209.     RexxTaskPtr = ^RexxTask;
  210.  
  211. Const
  212.  
  213. { Definitions for RexxTask flag bits                                   }
  214.  
  215.     RTFB_TRACE        = 0;        { external trace flag           }
  216.     RTFB_HALT        = 1;        { external halt flag            }
  217.     RTFB_SUSP        = 2;        { suspend task?                 }
  218.     RTFB_TCUSE        = 3;        { trace console in use?         }
  219.     RTFB_WAIT        = 6;        { waiting for reply?            }
  220.     RTFB_CLOSE        = 7;        { task completed?               }
  221.  
  222. { Definitions for memory allocation constants                          }
  223.  
  224.     MEMQUANT        = 16;        { quantum of memory space       }
  225.     MEMMASK        = $FFFFFFF0;    { mask for rounding the size    }
  226.  
  227.     MEMQUICK        = 1;        { EXEC flags: MEMF_PUBLIC       }
  228.     MEMCLEAR        = $00010000;    { EXEC flags: MEMF_CLEAR        }
  229.  
  230. { The SrcNode is a temporary structure used to hold values destined for
  231.  * a segment array.  It is also used to maintain the memory freelist.
  232. }
  233.  
  234. Type
  235.  
  236.     SrcNode = record
  237.     sn_Succ        : ^SrcNode;    { next node                     }
  238.     sn_Pred        : ^SrcNode;    { previous node                 }
  239.     sn_Ptr        : Address;    { pointer value                 }
  240.     sn_Size        : Integer;    { size of object                }
  241.     end;                { size: 16 bytes                }
  242.     SrcNodePtr = ^SrcNode;
  243.  
  244. VAR
  245.     RexxSysBase : Address;
  246.  
  247.  
  248. Function  AddClipNode(VAR lst: List; name: String; length: Integer; 
  249.             value: Address): RexxRsrcPtr;
  250.     External;
  251.  
  252. Function  AddRsrcNode(Lst : List; Name : String; Len : Integer): RexxRsrcPtr;
  253.     External;
  254.  
  255. Procedure ClearMem(Add : Address; Len : Integer);
  256.     External;
  257.  
  258. Procedure ClearRexxMsg(msg : RexxMsgPtr; Count : Integer);
  259.     External;
  260.  
  261. Function  CreateArgstring(S : String; len : Integer): Address;
  262.     External;
  263.  
  264. Function  CreateRexxMsg(rp : MsgPortPtr; ex, host : String) : RexxMsgPtr;
  265.     External;
  266.  
  267. Function  CurrentEnv(rxptr: RexxTaskPtr): Address;
  268.     External;
  269.  
  270. Procedure DeleteArgstring(As : Address);
  271.     External;
  272.  
  273. Procedure DeleteRexxMsg(pkt: RexxMsgPtr);
  274.     External;
  275.  
  276. Function  FillRexxMsg(mp: RexxMsgPtr; c, m : Integer): Boolean;
  277.     External;
  278.  
  279. Function  FindRsrcNode(list: ListPtr; name: String; tp : Integer): RexxRsrcPtr;
  280.     External;
  281.  
  282. Procedure FreePort(p : MsgPortPtr);
  283.     External;
  284.  
  285. Procedure FreeSpace(eptr, block: Address; len : Integer);
  286.     External;
  287.  
  288. Function  GetSpace(eptr: Address; len: Integer): Address;
  289.     External;
  290.  
  291. Procedure InitList(list: ListPtr);
  292.     External;
  293.  
  294. Function  InitPort(p : MsgPortPtr; name: String): Integer;
  295.     External;
  296.  
  297. Function  IsRexxMsg(mp: RexxMsgPtr): Boolean;
  298.     External;
  299.  
  300. Procedure RemClipNode(nd: RexxRsrcPtr);
  301.     External;
  302.  
  303. Procedure RemRsrcList(list: RexxRsrcPtr);
  304.     External;
  305.  
  306. Procedure RemRsrcNode(node: RexxRsrcPtr);
  307.     External;
  308.